home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / misc / amigem.lha / amigem / exec / memory.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-29  |  9.0 KB  |  382 lines
  1. #include <exec/alerts.h>
  2. #include <exec/execbase.h>
  3. #include <exec/tasks.h>
  4. #include <exec/memory.h>
  5. #include <exec/semaphores.h>
  6. #include <exec/devices.h>
  7. #include <exec/io.h>
  8. #include <clib/_exec.h>
  9. #include <stdio.h>
  10.  
  11. #include <amigem/fd_lib.h>
  12. #define LIBBASE struct ExecBase *SysBase
  13.  
  14. /*
  15.  * Allocate part of a MemChunk
  16.  */
  17. void SplitMemChunk(struct MemChunk **mc,APTR mem,ULONG size)
  18. {
  19.   struct MemChunk *next;
  20.   next=(*mc)->mc_Next;
  21.   if((ULONG)mem+size<(ULONG)(*mc)+(*mc)->mc_Bytes)
  22.   {
  23.     (*mc)->mc_Next=(struct MemChunk *)((ULONG)mem+size);
  24.     (*mc)->mc_Next->mc_Next=next;
  25.     (*mc)->mc_Next->mc_Bytes=((ULONG)(*mc)+(*mc)->mc_Bytes)-((ULONG)mem+size);
  26.     next=(*mc)->mc_Next;
  27.   }
  28.   if((ULONG)(*mc)<(ULONG)mem)
  29.   {
  30.     (*mc)->mc_Bytes=(ULONG)mem-(ULONG)(*mc);
  31.     next=*mc;
  32.   }
  33.   *mc=next;
  34. }
  35.  
  36. FD2(31,void *,Allocate,struct MemHeader *mh,A0,ULONG size,D0)
  37. {
  38.   struct MemChunk *p1,*p2;
  39.   size=(size+sizeof(struct MemChunk)-1)&~(sizeof(struct MemChunk)-1);
  40.   if(mh->mh_Free<size)
  41.     return NULL;
  42.   p1=(struct MemChunk *)&mh->mh_First;
  43.   p2=p1->mc_Next;
  44.   if(p2!=NULL)
  45.     for(;;)
  46.     {
  47.       if(p2->mc_Bytes>=size)
  48.       {
  49.         SplitMemChunk((struct MemChunk **)p1,p2,size);
  50.         break;
  51.       }
  52.       p1=p2;
  53.       p2=p1->mc_Next;
  54.       if(p2==NULL)
  55.         break;
  56.       if((ULONG)p2<(ULONG)p1+p1->mc_Bytes)
  57.         Alert(AN_MemCorrupt);
  58.     }
  59.   return p2;
  60. }
  61.  
  62. FD3(32,void,Deallocate,struct MemHeader *mh,A0,APTR mem,A1,ULONG size,D0)
  63. {
  64.   struct MemChunk *p1,*p2;
  65.   if(!(size=(size+sizeof(struct MemChunk)-1)&~(sizeof(struct MemChunk)-1)))
  66.     return;
  67.   p2  =(APTR)((ULONG)mem&~(sizeof(struct MemChunk)-1));
  68.   p2->mc_Bytes=size;
  69.   mh->mh_Free+=size;
  70.   if((p1=mh->mh_First)==NULL)
  71.   {
  72.     p2->mc_Next=NULL;
  73.     mh->mh_First=p2;
  74.   }
  75.   else
  76.     for(;;)
  77.     {
  78.       if(p1->mc_Next==NULL||(ULONG)p1->mc_Next>(ULONG)p2)
  79.       {
  80.         p2->mc_Next=p1->mc_Next;
  81.         p1->mc_Next=p2;
  82.         if((ULONG)p1+p1->mc_Bytes==(ULONG)p2)
  83.         {
  84.           p1->mc_Bytes+=size;
  85.           p2=p1;
  86.         }else if((ULONG)p1+p1->mc_Bytes>(ULONG)p2)
  87.           Alert(AN_FreeTwice);
  88.         p1=p2->mc_Next;
  89.         if(p1)
  90.           if((ULONG)p2+p2->mc_Bytes==(ULONG)p1)
  91.           {
  92.             p1->mc_Bytes+=p1->mc_Bytes;
  93.             p1->mc_Next=p1->mc_Next;
  94.           }
  95.           else if((ULONG)p2+p2->mc_Bytes>(ULONG)p1)
  96.             Alert(AN_FreeTwice);
  97.         break;
  98.       }
  99.       p1=p1->mc_Next;
  100.     }
  101. }
  102.  
  103. FD2(33,void *,AllocMem,ULONG size,D0,ULONG attrib,D1)
  104. { 
  105.   struct MemHeader *mh;
  106.   struct MemChunk *ret=NULL;
  107.   size=(size+sizeof(struct MemChunk)-1)&~(sizeof(struct MemChunk)-1);
  108.   Forbid();
  109.     mh=(struct MemHeader *)SysBase->MemList.lh_Head;
  110.     while(mh->mh_Node.ln_Succ!=NULL)
  111.     {
  112.       if(mh->mh_Free>=size&&!(attrib&~(MEMF_CLEAR|MEMF_REVERSE|mh->mh_Attributes)))
  113.       {
  114.         if(!(attrib&MEMF_REVERSE))
  115.           ret=Allocate(mh,size);
  116.         else
  117.         {
  118.           struct MemChunk *p1,*p2;
  119.           p1=(struct MemChunk *)&mh->mh_First;
  120.           p2=p1->mc_Next;
  121.           if(p2!=NULL)
  122.             for(;;)
  123.             {
  124.               if(p2->mc_Bytes>=size)
  125.                 ret=p1;
  126.               p1=p2;
  127.               p2=p1->mc_Next;
  128.               if(p2==NULL)
  129.                 break;
  130.               if((ULONG)p2<(ULONG)p1+p1->mc_Bytes)
  131.                 Alert(AN_MemCorrupt);
  132.             }
  133.           if(ret!=NULL)
  134.           {
  135.             p1=ret;
  136.             p2=p1->mc_Next;
  137.             ret=(struct MemChunk *)((char *)p2+p2->mc_Bytes-size);
  138.             SplitMemChunk((struct MemChunk **)p1,ret,size);
  139.             mh->mh_Free-=size;
  140.           }
  141.         }
  142.         if(ret!=NULL)
  143.         {
  144.           if(attrib&MEMF_CLEAR)
  145.           {
  146.             ULONG cnt,*p;
  147.             p=(ULONG *)ret;
  148.             cnt=size/sizeof(ULONG);
  149.             while(cnt--)
  150.               *p++=0;
  151.           }
  152.           break;
  153.         }
  154.       }
  155.       mh=(struct MemHeader *)mh->mh_Node.ln_Succ;
  156.     }
  157.   Permit();
  158.   return ret;
  159. }
  160.  
  161. FD2(35,void,FreeMem,void *mem,A1,ULONG size,D0)
  162. {
  163.   struct MemHeader *mh;
  164.   Forbid();
  165.     mh=(struct MemHeader *)SysBase->MemList.lh_Head;
  166.     while(mh->mh_Node.ln_Succ!=NULL)
  167.     {
  168.       if((ULONG)mem>=(ULONG)mh->mh_Lower&&(ULONG)mem<(ULONG)mh->mh_Upper)
  169.         Deallocate(mh,mem,size);
  170.     }
  171.   Permit();
  172. }
  173.  
  174. FD2(34,void *,AllocAbs,ULONG size,D0,void *mem,A1)
  175. {
  176.   struct MemChunk *ret=NULL;
  177.   struct MemHeader *mh;
  178.   size=(size+((ULONG)mem&(sizeof(struct MemChunk)-1))+
  179.         sizeof(struct MemChunk)-1)&~(sizeof(struct MemChunk)-1);
  180.   mem=(void *)((ULONG)mem&~(sizeof(struct MemChunk)-1));
  181.   Forbid();
  182.     mh=(struct MemHeader *)SysBase->MemList.lh_Head;
  183.     while(mh->mh_Node.ln_Succ!=NULL)
  184.     {
  185.       if((ULONG)mem>=(ULONG)mh->mh_Lower&&(ULONG)mem<=(ULONG)mh->mh_Upper)
  186.       {
  187.         struct MemChunk *p1,*p2;
  188.         p1=(struct MemChunk *)&mh->mh_First;
  189.         p2=p1->mc_Next;
  190.         if(p2!=NULL)
  191.         {
  192.           for(;;)
  193.           {
  194.             if((ULONG)p2+p2->mc_Bytes>=(ULONG)mem+size&&(ULONG)p2<=(ULONG)mem)
  195.             {
  196.               ret=p1;
  197.               break;
  198.             }
  199.             p1=p2;
  200.             p2=p1->mc_Next;
  201.             if(p2==NULL)
  202.               break;
  203.             if((ULONG)p2<(ULONG)p1+p1->mc_Bytes)
  204.               Alert(AN_MemCorrupt);
  205.           }
  206.           if(ret!=NULL)
  207.           {
  208.             ret=(struct MemChunk *)mem;
  209.             SplitMemChunk((struct MemChunk **)p1,ret,size);
  210.             mh->mh_Free-=size;
  211.             break;
  212.       }
  213.         }
  214.       }
  215.       mh=(struct MemHeader *)mh->mh_Node.ln_Succ;
  216.     }
  217.   Permit();
  218.   return ret;
  219. }
  220.  
  221. FD2(114,void *,AllocVec,ULONG size,D0,ULONG attrib,D1)
  222. {
  223.   ULONG *ret;
  224.   size+=sizeof(ULONG);
  225.   if((ret=(ULONG *)AllocMem(size,attrib))!=NULL)
  226.     *ret=size;
  227.   return ret+1;
  228. }
  229.  
  230. FD1(115,void,FreeVec,void *mem,A1)
  231. {
  232.   ULONG *p=(ULONG *)mem;
  233.   if(p!=NULL)
  234.   {
  235.     p--;
  236.     FreeMem(p,*p);
  237.   }
  238. }
  239.  
  240. FD1(37,struct MemList *,AllocEntry,struct MemList *ml,A0)
  241. {
  242.   struct MemList *ret;
  243.   ULONG i;
  244.   if((ret=(struct MemList *)AllocMem(sizeof(struct MemList)-sizeof(struct MemEntry)+
  245.           sizeof(struct MemEntry)*ml->ml_NumEntries,MEMF_PUBLIC))==NULL)
  246.     return (struct MemList *)(MEMF_PUBLIC|0x80ul<<(sizeof(APTR)-1)*8);
  247.   ret->ml_NumEntries=ml->ml_NumEntries;
  248.   for(i=0;i<ml->ml_NumEntries;i++)
  249.   {
  250.     if((ret->ml_ME[i].me_Addr=AllocMem(ml->ml_ME[i].me_Length,ml->ml_ME[i].me_Reqs))==NULL)
  251.     {
  252.       ml=(struct MemList *)((ULONG)ml->ml_ME[i].me_Reqs|0x80ul<<(sizeof(APTR)-1)*8);
  253.       for(;i-->0;)
  254.         FreeMem(ret->ml_ME[i].me_Addr,ret->ml_ME[i].me_Length);
  255.       FreeMem(ret,sizeof(struct MemList)-sizeof(struct MemEntry)+
  256.                   sizeof(struct MemEntry)*ret->ml_NumEntries);
  257.       return ml;
  258.     }
  259.     ret->ml_ME[i].me_Length=ml->ml_ME[i].me_Length;
  260.   }
  261.   return ret;
  262. }
  263.  
  264. FD1(38,void,FreeEntry,struct MemList *ml,A0)
  265. {
  266.   ULONG i;
  267.   for(i=0;i<ml->ml_NumEntries;i++)
  268.     FreeMem(ml->ml_ME[i].me_Addr,ml->ml_ME[i].me_Length);
  269.   FreeMem(ml,sizeof(struct MemList)-sizeof(struct MemEntry)+
  270.              sizeof(struct MemEntry)*ml->ml_NumEntries);
  271. }
  272.  
  273. FD5(103,void,AddMemList,ULONG size,D0,ULONG attributes,D1,LONG pri,D2,APTR base,A0,STRPTR name,A1)
  274. {
  275.   struct MemHeader *mh;
  276.   /* Should have to look here if it matches some other memheader */
  277.   mh=(struct MemHeader *)base;
  278.   mh->mh_Node.ln_Pri=pri;
  279.   mh->mh_Node.ln_Name=name;
  280.   mh->mh_Attributes=attributes;
  281.   mh->mh_First=(struct MemChunk *)(mh+1);
  282.   mh->mh_First->mc_Next=NULL;
  283.   mh->mh_First->mc_Bytes=size-sizeof(struct MemHeader);
  284.   mh->mh_Lower=base;
  285.   mh->mh_Upper=(APTR)((char *)base+size);
  286.   mh->mh_Free=size-sizeof(struct MemHeader);
  287.   Forbid();
  288.     Enqueue(&SysBase->MemList,&mh->mh_Node);
  289.   Permit();
  290. }
  291.  
  292. FD1(89,ULONG,TypeOfMem,void *mem,A1)
  293. {
  294.   ULONG ret=0;
  295.   struct MemHeader *mh;
  296.   Forbid();
  297.     mh=(struct MemHeader *)SysBase->MemList.lh_Head;
  298.     while(mh->mh_Node.ln_Succ!=NULL)
  299.     {
  300.       if((ULONG)mem>=(ULONG)mh->mh_Lower&&(ULONG)mem<=(ULONG)mh->mh_Upper)
  301.       {
  302.         ret=mh->mh_Attributes;
  303.         break;
  304.       }
  305.       mh=(struct MemHeader *)mh->mh_Node.ln_Succ;
  306.     }
  307.   Permit();
  308.   return ret;
  309. }
  310.  
  311. FD3(104,void,CopyMem,APTR source,A0,APTR dest,A1,unsigned long size,D0)
  312. {
  313.   UBYTE *s=(UBYTE *)source,*d=(UBYTE *)dest;
  314.   if(size&1)
  315.   {
  316.     *d++=*s++;
  317.     size--;
  318.   }
  319.   if(size&2)
  320.   {
  321.     *d++=*s++;
  322.     *d++=*s++;
  323.     size-=2;
  324.   }
  325.   size>>=2;
  326.   if(size)
  327.     do
  328.     {
  329.       *d++=*s++;
  330.       *d++=*s++;
  331.       *d++=*s++;
  332.       *d++=*s++;      
  333.     }
  334.     while(--size);    
  335. }
  336.  
  337. FD3(105,void,CopyMemQuick,ULONG *source,A0,ULONG *dest,A1,ULONG size,D0)
  338. {
  339.   if(size&4)
  340.   {
  341.     *dest++=*source++;
  342.     size-=4;
  343.   }
  344.   if(size&8)
  345.   {
  346.     *dest++=*source++;
  347.     *dest++=*source++;
  348.     size-=8;
  349.   }
  350.   size>>=4;
  351.   if(size)
  352.     do
  353.     {
  354.       *dest++=*source++;
  355.       *dest++=*source++;
  356.       *dest++=*source++;
  357.       *dest++=*source++;      
  358.     }
  359.     while(--size);
  360. }
  361.  
  362. FD1(36,ULONG,AvailMem,ULONG attributes,D1)
  363. { return 0; }
  364.  
  365. FD3(116,void *,CreatePool,ULONG memFlags,D0,ULONG puddleSize,D1,ULONG treshSize,D2)
  366. { return NULL; }
  367.  
  368. FD1(117,void,DeletePool,void *poolHeader,A0)
  369. {}
  370.  
  371. FD2(118,void *,AllocPooled,void *poolHeader,A0,ULONG memSize,D0)
  372. { return NULL; }
  373.  
  374. FD3(119,void,FreePooled,void *poolHeader,A0,void *memory,A1,ULONG memSize,D0)
  375. {}
  376.  
  377. FD1(129,void,AddMemHandler,struct Interrupt *memHandler,A1)
  378. {}
  379.  
  380. FD1(130,void,RemMemHandler,struct Interrupt *memHandler,A1)
  381. {}
  382.